//package kt.flows
//
//import kotlinx.coroutines.*
//import kotlinx.coroutines.flow.*
//import kotlin.system.measureTimeMillis
//
///**
// *  参考 [ https://book.kotlincn.net/text/flow.html ]
// * 1, 冷流
// * @sample showCoolFlow
// * flow 是冷流 , 在对simpleCoolFlow 进行初始化时，都不会调用  print   打印 flow start ,
// * 只有在调用 collect 时才会 调用  print 打印 flow start
// *
// * 2, 取消flow
// * @sample showCancelFlow
// *
// * 3 , asFlow
// * @sample showBuildFlow
// *
// * 4,map 过渡操作符 ， 在map操作中将返回一个值向下流去
// * @see showFlowMapOperator
// *
// * 5,transform 转换 在transform 内部可以进行 emit  发射操作，而map中不可以
// * @see showFlowTransform
// *
// * 6, take 限制emit 次数 ， take(2) 可以emit 2 次  ， 对 transform  , map 有效
// * @see showFlowTake
// *
// * 7 , reduce 末端操作符，最后返回一个值
// * @see showFlowReduce
// *
// * 8， flow是连续性的
// *
// * 9，flow中的上下文
// * @sample  showFlowContext
// *
// *10 , flowOn       todo 这里注意
// * [showFlowon]
// *
// * 11 , buffer      缓冲发射项，无需等待
// * @see showFlowBuffer
// *
// *
// * 12, conflate     合并发射项，不对每个值进行处理
// * [showFlowConflate]
// *
// * 13 , collectLatest       产生新值的时候，将取消执行其他块中的代码
// * [showFlowCollectLaster]
// *
// * 14 , zip     组合两个流的值 ， 两个flow中内容个数要相同 ， 否则要注意取舍
// * @sample  showFlowZip
// *
// * 15 , combine （联合）
// * [showFlowCombine]
// *
// *
// * 16,  flatMapConcat
// * 17,  flatMapMerge
// * 18,  flatMapLatest
// *
// *
// * 19, onCompletion
// * [showCompletion]
// *
// *
// * 20,开启flow
// * [showStartFlow]
// *
// *
// * 21 , lauchIn      在单独的协程中执行流
// * [showlauchFlow]
// *
// *
// * 22 , cancel 取消
// * [showCancel]
// *
// */
//
//
//fun main() {
//
////    flowsShow()
////    showCoolFlow()
////    showCancelFlow()
////    showBuildFlow()
////    showFlowMapOperator()
////    showFlowTransform()
////    showFlowTake()
////    showFlowReduce()
////    showFlowContext()
////    showFlowon()
////    showFlowBuffer()
////    showFlowConflate()
////    showFlowCollectLaster()
////    showFlowZip()
////    showFlowCombine()
////    showMapConcat()
////    showMapMerge()
////    showMapLast()
////    showTryCatch()
////    showCompletion()
////    showStartFlow()
////    showlauchFlow()
//    showCancel()
//}
//
//
//
//fun showCancel(){
//    runBlocking {
//        simplePrint()
//                .collect { value ->
//                    if (value == 4) cancel()
//                    println("value = $value")
//                }
//    }
//}
///*
//        Emitting 1
//        value = 1
//        Emitting 2
//        value = 2
//        Emitting 3
//        value = 3
// */
//
//
//
//
//
//fun showlauchFlow(){
//    runBlocking {
//        events().onEach { event ->
//            println("event $event")
//        }.launchIn(this)        //<--- 在单独的协程中执行流
//        println("done ")
//    }
//}
///*
//        done
//        event 1
//        event 2
//        event 3
// */
//
//
//
//
//// 模仿事件流
//fun events(): Flow<Int> = (1..3).asFlow().onEach { delay(100) }
//
//fun showStartFlow(){
//    runBlocking {
//        events().onEach { event ->
//            println("event $event")
//        }.collect()
//        println("done ")
//    }
//}
///*
//event 1
//event 2
//event 3
//done
// */
//
//
//
//fun showCompletion(){
//    runBlocking {
//        simpleCoolFlow().onCompletion {
//            println("completion with $it")
//        }.collect {
//            value ->
////            check(value <= 4){"collect $value"}
//            println("value = $value")
//        }
//    }
//}
//
//
//fun simplePrint(): Flow<Int> = flow {
//    for (i in 1..3) {
//        println("Emitting $i")
//        emit(i) // 发射下一个值
//    }
//}
//
//
//fun showTryCatch(){
//    runBlocking {
//        try {
//            simplePrint().collect { value ->
//                println("value = $value")
//                check(value <= 1){
//                    "collect check $value"
//                }
//            }
//        }catch (e: Exception){
//            println("catch = $e")
//        }
//    }
//}
//
//
//fun showMapLast(){
//    runBlocking {
//        val startTime = System.currentTimeMillis() // 记录开始时间
//        (1..3)
//                .asFlow()
//                .onEach { delay(100) } // 每 100 毫秒发射一个数字
//                .flatMapLatest   { requestFlow(it) }
//                .collect { value -> // 收集并打印
//                    println("$value at ${System.currentTimeMillis() - startTime} ms from start")
//                }
//    }
//    /*
//            1: First at 131 ms from start
//            2: First at 239 ms from start
//            3: First at 345 ms from start
//            3: Second at 847 ms from start
//
//     */
//
//}
//
//
//fun showMapMerge(){
//
//    runBlocking {
//        val startTime = System.currentTimeMillis() // 记录开始时间
//        (1..3)
//                .asFlow()
//                .onEach { delay(100) } // 每 100 毫秒发射一个数字
//                .flatMapMerge  { requestFlow(it) }
//                .collect { value -> // 收集并打印
//                    println("$value at ${System.currentTimeMillis() - startTime} ms from start")
//                }
//
//    }
//
//    /*
//        1: First at 137 ms from start
//        2: First at 241 ms from start
//        3: First at 353 ms from start
//        1: Second at 640 ms from start
//        2: Second at 752 ms from start
//        3: Second at 864 ms from start
//     */
//}
//
//fun showMapConcat(){
//
//    runBlocking {
//        val startTime = System.currentTimeMillis() // 记录开始时间
//        (1..3)
//                .asFlow()
//                .onEach { delay(100) } // 每 100 毫秒发射一个数字
//                .flatMapConcat { requestFlow(it) }
//                .collect { value -> // 收集并打印
//                    println("$value at ${System.currentTimeMillis() - startTime} ms from start")
//                }
//
//    }
//
//}
//
//fun requestFlow(i: Int): Flow<String> = flow {
//    emit("$i: First")
//    delay(500) // 等待 500 毫秒
//    emit("$i: Second")
//}
//
//
//
//
//
//
//fun showFlowCombine(){
//    runBlocking {
//        var nums = (1..4).asFlow().onEach { delay(300) }
//
//        var strs = flowOf("one" , "two" , "three" , "four").onEach { delay(400) }
//
//        val startTime = System.currentTimeMillis() // 记录开始的时间
//
//        nums.combine(strs){
//            a , b -> "$a --> $b"
//        }.collect {
//            println("result = $it   ; at ${System.currentTimeMillis() - startTime} ms")
//        }
//    }
//
//}
///*
//    result = 1 --> one   ; at 428 ms
//    result = 2 --> one   ; at 650 ms
//    result = 2 --> two   ; at 838 ms
//    result = 3 --> two   ; at 962 ms
//    result = 3 --> three   ; at 1242 ms
//    result = 4 --> three   ; at 1273 ms
//    result = 4 --> four   ; at 1647 ms
// */
//
//
//
//
//fun showFlowZip(){
//    runBlocking {
//        var nums = (1..5).asFlow()
//        var strs = flowOf("one" , "two" , "three" , "four")
//        val startTime = System.currentTimeMillis() // 记录开始的时间
//
//        nums.zip(strs){
//            a , b -> "$a --> $b"
//        }.collect {
//            println("result = $it   ; at ${System.currentTimeMillis() - startTime} ms ; startTime = $startTime")
//        }
//    }
//
//}
///*
//        result = 1 --> one   ; at 21 ms
//        result = 2 --> two   ; at 22 ms
//        result = 3 --> three   ; at 22 ms
//        result = 4 --> four   ; at 22 ms
//
// */
//
//
//
//
//
//fun showFlowCollectLaster(){
//
//    runBlocking {
//        var time = measureTimeMillis {
//            simpleCoolFlow()
//                    .collectLatest { value ->
//                println("collect value = $value")
//                delay(300)
//                println("done $value")
//            }
//        }
//        println("collect time = $time")
//    }
//}
///*
//        flow start ..
//        collect value = 1
//        collect value = 2
//        collect value = 3
//        collect value = 4
//        collect value = 5
//        collect value = 6
//        done 6
//        collect time = 1015
// */
//
//
//
//
//
//
//
//
//fun showFlowConflate(){
//    runBlocking {
//
//        var time = measureTimeMillis {
//            simpleCoolFlow()
////                    .conflate()
//                    .collect {
//                        value ->
//                        delay(100)
//                        println("value = $value")
//                    }
//        }
//
//        println("time = $time")
//    }
//}
//
//// time = 1336      // not use conflate
//// time = 809       // use conflate
//
//
//
//fun showFlowBuffer(){
//    runBlocking {
//        var time = measureTimeMillis {
//            simpleCoolFlow()
//                    .buffer()
//                    .collect {
//                        delay(600)
//                        println("value = $it")
//                    }
//        }
//        println("time = $time")
//    }
//}
//// time = 4304   // 没使用buffer
//// time = 3795   // use buffer
//
//
//
//
//
//
//fun simpleFlowOn() : Flow<Int> = flow {
//    for (i in 1..3) {
//        Thread.sleep(100) // 假装我们以消耗 CPU 的方式进行计算
//        log("Emitting $i") //
//        emit(i) // 发射下一个值
//    }
//}.flowOn(Dispatchers.Default)       //  在流构建器中改变消耗 CPU 代码上下文的正确方式
//
//
//fun showFlowon(){
//    runBlocking {
//        simpleFlowOn().collect {
//            log("collect $it")
//        }
//    }
//}
//
///**
// * [DefaultDispatcher-worker-1] Emitting 1
//    [main] collect 1
//    [DefaultDispatcher-worker-1] Emitting 2
//    [main] collect 2
//    [DefaultDispatcher-worker-1] Emitting 3
//    [main] collect 3
// */
//
//
//
//
//
//fun log(msg : String) = println("[${Thread.currentThread().name}] $msg")
//
//fun showFlowContext(){
//    runBlocking {
//        simpleCoolFlow().collect { value ->
//        kotlin.run {
//            log("collect $value")
//            }
//
//        }
//    }
//}
//
//
//
//fun showFlowReduce(){
//    runBlocking {
//        var sum = (1..5).asFlow()
//                .map {
//                    println("value = ${it * it}")
//                    it * it
//                }
//                .reduce{ a , b ->
//                    println("a = $a ;  b = $b")
//                    a + b
//                }
//        println("sum = $sum")
//    }
//}
//
//
//
//
//fun numbers(): Flow<Int> = flow {
//    try {
//        emit(1)
//        emit(2)
//        println("This line will not execute")
//        emit(3)
//    } finally {
//        println("Finally in numbers")
//    }
//}
//
//
//
//fun showFlowTake(){
//    runBlocking {
//        numbers()
//                .take(2)
//                .collect {
//                    println("collect = $it")
//                }
//    }
//}
//
//
//
//
//
//fun showFlowTransform(){
//    runBlocking {
//        (1..6).asFlow()
//                .transform { request ->
//                    emit("add emit $request")
//                    emit(performRequest(request))
//                }
//                .take(4)        // 有效
//                .collect { response ->
//                    println("response $response")
//                }
//    }
//}
//
///**
// *  response add emit 1
//    response request 1
//
//    response add emit 2
//    response request 2
//
//    response add emit 3
//    response request 3
// */
//
//
//
//
//suspend fun performRequest(request : Int) : String{
//    delay(100)
//    return "request $request"
//}
//
//fun showFlowMapOperator(){
//    runBlocking {
//        (1..6).asFlow()
//                .map {      // 过渡
//                    request -> performRequest(request)
////                    emit()        // error
//                }
//                .take(2)
//                .collect { response ->
//                    println("response $response")
//                }
//
//    }
//
//}
//
//fun showBuildFlow(){
//    runBlocking {
////        (1..6).asFlow().collect {
////            value ->  println("value = $value")
////        }
//
//        var intArrayList = arrayListOf<Int>(1,2,3,4,5,6,7)
//        var intList = listOf<Int>(1,2,3,4,5,6,7)
//        var strList = listOf<String>("1" , "2" , "aaa" , "bb"  , "ssss11")
//
//        var multiList = mutableListOf<Int>(1,2,3,4,5,6,7)
//
//        multiList.asFlow().collect {
//            value ->  println("multi list value = $value")
//        }
//    }
//}
//
//
//fun showCancelFlow(){
//    runBlocking {
//
//        withTimeoutOrNull(250) { // 在 250 毫秒后超时
//            cancelFlow().collect { value -> println(value) }
//        }
//        println("Done")
//
//    }
//
//}
//
//fun cancelFlow() : Flow<Int> = flow {
//    for (i in 1..6) {
//        delay(100)
//        println("Emitting $i")
//        emit(i)
//    }
//
//}
//
//
//
//fun showCoolFlow(){
//
//    runBlocking {
//        println("calling simple function ..")
//        val flows = simpleCoolFlow()
//
//        println("call flow collect .")
//
//        flows.collect {
//            value ->
//            println("value = $value")
//        }
//
//        println("call collect again ...")
//
//        flows.collect {
//            value ->
//            println("value = $value")
//        }
//    }
//
//}
//
//
//
//// flow 是冷流 , 在对simpleCoolFlow 进行初始化时，都不会调用  print   打印 flow start
//// 只有在调用 collect 时才会 调用  print 打印 flow start
//fun simpleCoolFlow() : Flow<Int> = flow {
//    println("flow start ..")
//
//    for (i  in 1..6){
//        delay(100)
//        emit(i)
//    }
//
//}
//
//
//
//fun flowsShow(){
//
//
//    runBlocking {
//        flow{
//            emit(1)
//            emit(2)
//            emit(3)
//            emit(4)
//        }.filter {
//            it > 2
//        }.map {
//            it * 2
//        }.take(2)
//                .collect {
//                    println("$it")
//                }
//    }
//
//}
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
